<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>C++ Tutorial Keywords</title>
  <meta
 content="C++ Tutorial: C++ Keywords Keywords"
 name="description" />
  <meta
 content="C++ Tutorial, C++ Keywords, catch, const, const_cast, dynamic_cast, enum, mutable, namespaces, register, reinterpret_cast, static, static_cast, this, throw, try, typedef, typeid, typename, virtual, volatile"
 name="keywords" />
  <meta http-equiv="Content-Type"
 content="text/html; charset=ISO-8859-1" />
  <link type="text/css" rel="stylesheet" href="../images/bogostyleWidePre.css" />
</head>
<body>
<div id="page" align="center">
<div id="content" style="width: 800px;">
<div id="logo">
<div class="whitetitle" style="margin-top: 70px;">bogotobogo </div>
</div>
<div id="topheader">
<div class="headerbodytext" align="left"><br />
<strong>Bogotobogo</strong><br />
contact@bogotobogo.com </div>
<div class="smallgraytext" id="toplinks"><a href="../index.html">Home</a>
| <a href="../sitemap.html">Sitemap</a>
| <a href="../blog" target="_blank">Contact Us</a>
</div>
</div>
<div id="menu">
<div class="smallwhitetext" style="padding: 9px;" align="right"><a
 href="../index.html">Home</a>
| <a href="../about_us.html">About Us</a>
| <a href="../products.html">Products</a>
| <a href="../our_services.html">Our Services</a>
| <a href="../blog" target="_blank">Contact Us</a>
</div>
</div>
<div id="submenu">
<div class="smallgraytext" style="padding: 9px;" align="right">
<a href="../gif.html">Gif</a> 
|<a href="../java_applet.html">JavaApplet/Web Start</a>
| <a href="../flash.html">Flash</a>
| <a href="../shockwave.html">ShockWave</a>
| <a href="../svg.html">SVG</a>
| <a href="../iPhone.html">iPhone/iPad</a>
| <a href="../android.html">Android</a>
| <a href="../OnHTML5.html">HTML5</a>
| <a href="../Algorithms/algorithms.html">Algorithms</a>
| <a href="../News/NewsMain.html">News</a>
| <a href="../cplusplus/cpptut.html">C++</a>
| <a href="../Java/tutorial/on_java.html">Java</a>
| <a href="../php/phptut.html">PHP</a>
| <a href="../DesignPatterns/introduction.html">Design Patterns</a>
| <a href="../python/pytut.html">Python</a> 
| <a href="../CSharp/.netframework.html">C#</a>
| <a href="../forums.html">Forums</a> 
| <a href="../VisualBasicSQL/introduction.html">Visual Basic</a>
</div>
</div>


<div id="contenttext">
<br />
<br />
<!-- Use of this code assumes agreement with the Google Custom Search Terms of Service. -->
<!-- The terms of service are available at http://www.google.com/cse/docs/tos.html -->
<form name="cse" id="searchbox_demo" action="http://www.google.com/cse">
  <input type="hidden" name="cref" value="" />
  <input type="hidden" name="ie" value="utf-8" />
  <input type="hidden" name="hl" value="" />
  <input name="q" type="text" size="40" />
  <input type="submit" name="sa" value="Search" />
</form>
<script type="text/javascript" src="http://www.google.com/cse/tools/onthefly?form=searchbox_demo&lang="></script>


<div id="bookmarkshare">
<script type="text/javascript">var addthis_config = {"data_track_clickback":true};</script>
<a class="addthis_button" href="http://www.addthis.com/bookmark.php?v=250&amp;username=khhong7"><img src="http://s7.addthis.com/static/btn/v2/lg-share-en.gif" width="125" height="16" alt="Bookmark and Share" style="border:0"/></a><script type="text/javascript" src="http://s7.addthis.com/js/250/addthis_widget.js#username=khhong7"></script>
</div>



<br />
<div style="padding: 10px;"><span class="titletext">C++ Tutorial: Keyword</span></div>


<img src="../images/cplusplus/cpp_logo.jpg" alt="cplusplus logo"/>


<div class="bodytext" style="padding: 12px;" align="justify"> 
<div class="subtitle_2nd" id="keywords">C++ Keywords</div>
<br />
<br />


 <table border="2" cellpadding="7" cellspacing="0">
  <tbody>
	<tr>
		<th>Keyword</th>
		<th>Description</th>
	</tr>
	<tr>
		<td> and </td>
		<td> alternative to &amp;&amp; operator </td>
	</tr>
	<tr>
		<td>and_eq</td>
		<td>alternative to &amp;= operator</td>
	</tr>
	<tr>

	<td>asm</td>
	<td>insert an assembly instruction</td>
	</tr>
	<tr>
		<td>auto</td><td> declare a local variable</td>
	</tr>
	<tr>
		<td>bitand</td><td>alternative to bitwise &amp; operator</td>
	</tr>
	<tr>
		<td>bitor</td><td>alternative to | operator</td>
	</tr>
	<tr>
		<td>bool</td><td>declare a boolean variable</td>
	</tr>
	<tr>
		<td>break</td><td>break out of a loop</td>
	</tr>
	<tr>
		<td>case</td><td>a block of code in a switch statement</td>
	</tr>
	<tr>
		<td><a href="exceptions.html#tryandcatch" target="_blank">catch</a> </td>
		<td> handles exceptions from throw </td>
	</tr>
	<tr>
		<td>char </td>
		<td> declare a character variable</td>
	</tr>
	<tr>
		<td> class </td>
		<td>declare a class </td>
	</tr>

	<tr>
		<td> compl </td>
		<td> alternative to ~ operator </td>
	</tr>
	<tr>
		<td> <a href="#const">const</a></td>
		<td> declare immutable data or functions that do not change data</td>
	</tr>
	<tr>
		<td> <a href="typecast.html#const_cast" target="_blank">const_cast</a></td>
		<td> cast from const variables</td>
	</tr>
	<tr>
		<td> continue</td>
		<td> bypass iterations of a loop </td>
	</tr>
	<tr>
		<td> default</td>
		<td> default handler in a case statement</td>
	</tr>
	<tr>
		<td>delete</td>
		<td>make dynamic memory available</td>
	</tr>

	<tr>
		<td> do </td>
		<td> looping construct</td>
	</tr>
	<tr>
		<td>double</td>
		<td> declare a double precision floating-point variable </td>
	</tr>
	<tr>
		<td><a href="dynamic_cast.html" target="_blank">dynamic_cast</a></td>
		<td> perform runtime casts</td>
	</tr>
	<tr>
		<td> else </td>
		<td>alternate case for an if statement</td>
	</tr>
	<tr>
		<td><a href="#enum"> enum</a> </td>
		<td>create enumeration types</td>
	</tr>
	<tr>
		<td> explicit </td>
		<td> only use constructors when they exactly match</td>
	</tr>
	<tr>
		<td> export </td>
		<td> allows template definitions to be separated from their declarations</td>
	</tr>
	<tr>
		<td> false </td>
		<td> a constant representing the boolean false value</td>
	</tr>
	<tr>
		<td> float </td>
		<td> declare a floating-point variable</td>
	</tr>

	<tr>
		<td> for</td>
		<td> looping construct</td>
	</tr>
		<td> friend </td>
		<td> grant non-member function access to private data</td>
	</tr>
	<tr>
		<td> goto </td>
		<td> jump to a different part of the program</td>
	</tr>
	<tr>
		<td> if </td>
		<td> execute code based on the result of a test</td>
	</tr>
	<tr>
		<td> inline </td>
		<td> optimize calls to short functions</td>
	</tr>
	<tr>
		<td> int </td>
		<td> declare an integer variable</td>
	</tr>
	<tr>
		<td> long </td>
		<td> declare a long integer variable</td>
	</tr>
	<tr>
		<td> <a href="#mutable">mutable</a> </td>
		<td> override a const variable </td>
	</tr>
	<tr>
		<td><a href="#namespace">namespace</a> </td>
		<td> partition the global namespace by defining a scope </td>
	</tr>
	<tr>
		<td> new</td>
		<td> allocate dynamic memory for a new variable</td>
	</tr>
	<tr>
		<td>not</td>
		<td> alternative to ! operator</td>
	</tr>
	<tr>
		<td> not_eq </td>
		<td> alternative to != operator</td>
	</tr>
	<tr>
		<td><a href="operatoroverloading.html" target="_blank">operator</a> </td>
		<td> create overloaded operator functions</td>
	</tr>
	<tr>
		<td> or</td>
		<td> alternative to || operator</td>
	</tr>
	<tr>
		<td> or_eq</td>
		<td> alternative to |= operator</td>
	</tr>
	<tr>
		<td> private </td>
		<td>declare private members of a class</td>
	</tr>
	<tr>
		<td> protected </td>
		<td> declare protected members of a class</td>
	</tr>
	<tr>
		<td> public </td>
		<td> declare public members of a class</td>
	</tr>
	<tr>
		<td> <a href="#register">register</a> </td>
		<td> request that a variable be optimized for speed</td>
	</tr>
	<tr>
		<<td> <a href="typecast.html#reinterpret_cast" target="_blank">reinterpret_cast</a></td>
		<td> change the type of a variable</td>
	</tr>
	<tr>
		<td> short </td>
		<td> declare a short integer variable</td>
	</tr>

	<tr>
		<td> signed </td>
		<td> modify variable type declarations</td>
	</tr>
	<tr>
		<td> sizeof</td>
		<td> return the size of a variable or type</td>
	</tr>
	<tr>
		<td> <a href="statics.html" target="_blank">static</a> </td>
		<td> create permanent storage for a variable</td>
	</tr>
	<tr>
		<td> <a href="typecast.html#static_cast" target="_blank">static_cast</a></td>
		<td> perform a nonpolymorphic cast</td>
	</tr>
	<tr>
		<td> struct </td>
		<td> define a new structure</td>
	</tr>

	<tr>
		<td> switch </td>
		<td> execute code based on different possible values for a variable</td>
	</tr>
	<tr>
		<td><a href="templates.html" target="_blank">template</a> </td>
		<td> create generic functions</td>
	</tr>
	<tr>
		<td> <a href="this_pointer.html" target=_blank">this</a></td>
		<td> a pointer to the current object</td>
	</tr>
	<tr>
		<td><a href="exceptions.html#tryandcatch" target="_blank">throw</a> </td>
		<td> throws an exception</td>
	</tr>
	<tr>
		<td> true </td>
		<td> a constant representing the boolean true value</td>
	</tr>

	<tr>
		<td><a href="exceptions.html#tryandcatch" target="_blank">try</a> </td>
		<td> execute code that can throw an exception</td>
	</tr>
	<tr>
		<td> <a href="#typedef">typedef</a></td>
		<td> create a new type name from an existing type</td>
	</tr>
	<tr>
		<td><a href="dynamic_cast.html#typeid" target="_blank">typeid </a></td>
		<td> describes an object</td>
	</tr>
	<tr>
		<td><a href="templates.html" target="_blank">typename</a> </td>
		<td> declare a class or undefined type</td>
	</tr>
	<tr>
		<td> union </td>
		<td> a structure that assigns multiple variables to the same memory location </td>
	</tr>

	<tr>
		<td>unsigned</td>
		<td>declare an unsigned integer variable</td>
	</tr>
	<tr>
		<td>using</td>
		<td>import complete or partial namespaces into the current scope</td>
	</tr>
	<tr>
		<td> <a href="virtualfunctions.html" target="_blank">virtual</a> </td>
		<td> create a function that can be overridden by a derived class</td>
	</tr>
	<tr>
		<td> void </td>
		<td>declare functions or data with no associated data type</td>
	</tr>

	<tr>
		<td><a href="#volatile">volatile</a> </td>
		<td>warn the compiler about variables that can be modified unexpectedly</td>
	</tr>
	<tr>
		<td> void </td>
		<td>declare functions or data with no associated data type</td>
	</tr>
	<tr>
		<td> wchar_t </td>
		<td>declare a wide-character variable</td>
	</tr>
	<tr>
		<td> while </td>
		<td>looping construct</td>
	</tr>
	<tr>
		<td> xor </td>
		<td>alternative to ^ operator</td>
	</tr>
	<tr>
		<td> xor_eq </td>
		<td>alternative to ^= operator</td>
	</tr>
</tbody>
</table>
<br />
<br />
<br />
<br />

<br />
<br />


<div class="subtitle" id="const">const</div>
<p><strong>const</strong> qualifier allows us to ask compiler to enforce a semantic constraint: 
a particular object should not be modified. It also allows us to tell other programmers that a value should 
remain invariant. The general form for creating a constant is:</p>
<pre>
const type name = value;
</pre>
<p>Note that we initialize a <strong>const</strong> in the declaration. So, the following line is an error:</p>
<pre>
const int cint;
cint = 10;  // too late
</pre>
<p>We'll get an error message something like this:</p>
<pre>
error: 'cint' : const object must be initialized if not extern
error: 'cint' : you cannot assign to a variable that is const
</pre>
<p>If we don't provide a value when we declare the constant, it ends up with an unspecified value that we cannot modify.</p>
<br />

<div class="subtitle_2nd" id="pointers">pointers</div>
<p>For <strong>pointers</strong>, we can specify whether the pointer itself is <strong>const</strong>, the data it points to is <strong>const</strong>, 
both, or neither:</p>
<pre>
char str[] = "constantness";
char *p = str;		//non-const pointer to non-const data
const char *pc = str;	//non-const pointer to const data
char *cp = str;		//const pointer to non-const data
const char *cpc = str;	//const pointer to const data
</pre>
<p>When <strong>const</strong> appears to the left of the *, what's pointed to is constant, 
and if <strong>const</strong> appears to the right of the *, 
the pointer itself is constant. If <strong>const</strong> appears on both sizes, both are constant.</P>
<p>Using <strong>const</strong> with pointers has subtle aspects. Let's declare a pointer to a constant:</p>
<pre>
int year = 2012;
const int *ptr = &year;
*ptr = 2020;	// not ok because ptr points to a const int
</pre>
<p>How about the following code:</p>
<pre>
const int year = 2012;
int *p = &year;  // not ok
</pre>
<p>C++ doesn't allow the last line for simple reason: if we can assign the address of <strong>year</strong> to <strong>p</strong>, 
then we can cheat and use <strong>p</strong> to modify the value of <strong>year</strong>. That doesn't make sense because <strong>year</strong>
is declared as <strong>const</strong>. C++ prohibits us from assigning the address of a <strong>const</strong> to a <strong>non-const</strong> 
pointer.</p>
<br />

<div class="subtitle_2nd" id="iterators">STL iterators</div>
<p>Since STL iterators are modeled on pointers, an <strong>iterator</strong> behaves mush like a <strong>T*</strong> pointer.
So, declaring an <strong>iterator</strong> as <strong>const</strong> is like declaring a pointer <strong>const</strong>. 
If we want an iterator that points to something that can't be altered (<strong>const T*</strong>), we want to use a <strong>const_iterator</strong>:
</p>
<pre>
vector&lt;int&gt; v;
vector&lt;int&gt;::<font color="red">const_iterator</font> itc = v.begin();
*itc = 2012; 	// error: *itc is cost
++itc;		// ok, itc is not const
</pre>
<p>How about <strong>T*const</strong> iterator:</p>
<pre>
vector&lt;int&gt; v;
<font color="red">const</font> vector&lt;int&gt;::<font color="red">iterator</font> cit = v.begin;
*cit = 2012;	// ok
++cit;		// error: cit is const
</pre>
<br />

<div class="subtitle_2nd" id="array">arrays with const</div>
<p>Making a function to display the array is simple. We pass the name of the array and the number of elements to the function.
However, there are some implications. We need to guarantee that the display doesn't change the original array. 
In other words, we need to guard it from altering the values of array. That kind of protection comes automatically with 
ordinary parameters of the function because C++ passes them by value, and the function plays with a copy. But functions that 
use an array play with the original. To keep a function from accidentally modifying the contents of an array, we can 
use the keyword <strong>const</strong>:</p>
<pre>
void display_array(<font color="red">const</font> int arr[], int sz);
</pre>
<p>This declaration says that the pointer <strong>arr</strong> points to constant data, which means that we can't use
<strong>ar</strong> to alter the data.</p> 
<br />
<br />

<div class="subtitle" id="enum">enum (Enumerations)</div>
<p>An <strong>enum</strong> is a very simple user-defined type, specifying its set of values as symbolic constants.</p>
<pre>
#include &lt;iostream&gt;

enum Month {
	Jan = 1, Feb, Mar, Apr, May, June,
	Jul, Aug, Sep, Oct, Nov, Dec
};  

int main()
{
	using namespace std;

	Month f = Feb;
	Month j = Jul;

	cout << "f = " << f << endl;
//	f = 2;                  // error: cannot convert from 'int' to 'Month'
	int jj = j;             // allowed: can get the numeric value of a 'Month'
	Month jjj = Month(7);   // Convering int to 'Month'

	cout << "jj = " << jj << ", jjj = " << jjj << endl;
	return 0;
}
</pre>
<p>Output is:</p>
<pre>
f = 2
jj = 7, jjj = 7
</pre>
<p>Let's look at another usage example of <strong>enum</strong>:</p>
<pre>
<font color="red">#define NumArrays 10</font>

class ArrayObj
{
private:
	int array[NumArrays];
};

int main()
{
	ArrayObj a;
	return 0;
}
</pre>
<p>Here, <strong>#define</strong> does its job. However, we can use <strong>const</strong> instead.
<strong>const</strong> qualifier lets us specify the <strong>type</strong> explicitly as well as we can use <strong>
scoping</strong> rules to limit the definition to particular functions or files. In other words, there's no way to create 
a class-specific constant using a <strong>#define</strong>, because <strong>#define</strong> doesn't respect scope.</p>
<pre>
class ArrayObj
{
private:
	<font color="red">static const int NumArrays = 5;</font>
	int array[NumArrays];
};
</pre>
<p>We can also use <strong>enum</strong> for the array size:</p>
<pre>
class ArrayObj
{
private:
	<font color="red">enum {NumArrays = 5};</font>
	int array[NumArrays];
};
</pre>
<br />
<br />


<div class="subtitle" id="mutable">Mutable</div>
<p>To allow a class data member to be modified even though it is the data member of a 
<strong>const</strong> object, we can declare the data member as <strong>mutable</strong>. 
A mutable member is a member that is never <strong>const</strong>, 
even when it is the data member of a <strong>const</strong> object. 
A mutable member can always be updated, even in a <strong>const</strong> member function.</p>
<pre>
struct account
{
     char name[50];
     <font color="red">mutable</font> int id;
};

<font color="red">const</font> account ac = "{Bush", 0, ....};
strcpy(ac.name, "Obama"}    // not allowed
ac.id++;                    // allowed
</pre>
<br />
<p>The following example has an error because it tries to modify a variable which in a <strong>const</strong> 
member function:</p>
<pre>
#include &lt;iostream&gt;
#include &lt;cstring&gt;

class MyText
{
public:
	std::size_t getLength() const;
private:
	char * ptrText;
	<font color="red">std::size_t txtLen;</font>
};

std::size_t MyText::getLength() <font color="red">const</font>
{
	// error: l-value specifies const object
	// cannot assign to txtLen because it is in a const member function
	txtLen = std::strlen(ptrText); 
	return txtLen;
}
</pre>
<p>We can solve the problem. <strong>mutable</strong> frees non-static data members from the <strong>const</strong> 
constraints:</p>
<pre>
#include &lt;iostream&gt;
#include &lt;cstring&gt;

class MyText
{
public:
	std::size_t getLength() const;
private:
	char * ptrText;
	<font color="red">mutable</font> std::size_t txtLen;
};

std::size_t MyText::getLength() const
{
	txtLen = std::strlen(ptrText);  // ok
	return txtLen;
}
</pre>
<br />
<br />
<div class="subtitle" id="namespace">Namespaces</div>
<p>As programming projects grow large, the potential for name conflicts increases. The language mechanism for organizing classes, functions, data, and types into an identifiable and named part of a program without defining a type is a <strong>namespace</strong>. The C++ standard provides namespace which allows us to have greater control over the scope of names.<p>
<p>The following code uses <strong>namespace</strong> to create two namespaces, <strong>Stock</strong>, and <strong>Market</strong>: </p>
<pre>
namespace Stock {
	double penny;	
	void order();
	int amount;
	struct Option { ... };
}

namesapce Market {
	double dollar;	
	void order();
	int amount;
	struct Purchase { ... };
}
</pre>
<p>The names in any one namespace don't conflict with names in another namespace. So, the <strong>order</strong> in <strong>Stock</strong> is not confused with the <strong>order</strong> in <strong>Market</strong> </p>
<p>Namespaces can be located at the global level or inside other namespaces, but they cannot be in a block. Therefore, a name declared in a namespace has <strong>external linkage</strong> by default. </p>
<p>Namespaces are <strong>open</strong>. In other words, we can add names to existing namespaces. For instance, we can add another name to the existing list of names in <strong>Stock</strong>:</p>
<pre>
namespace Stock {
	string getCompanyName();
}
</pre>
<p>The original <strong>Stock</strong> namespace provides a prototypes for <strong>order()</strong> function. We can provide the code for the function later in the file or in another file by using the <strong>Stock</strong> namespace again:</p>
<pre>
namespace Stock {
	void order() {
		...
	}
}
</pre>
<p>How do we access names in a given namespace?<br />
We use the scope-resolution operator (::), to qualify a name with its namespace:</p>
<pre>
Stock::amount = 200;
Market::Purchase p;
Market::order();
</pre>
<p>Just variable name, such as <strong>penny</strong> is called <strong>unqualified name</strong>, which a name with the namespace, as in <strong>Market::dollar</strong> is called <strong>qualified name</strong>.</p>


<br />
<br />
<div class="subtitle" id="register">Register</div>
<p>The <strong>register</strong> keyword is a hint to the compiler that we want it to provide fast access to the variable, perhaps by using a CPU register instead of the stack to handle a particular variable. The CPU can access a value in one of its registers more quickly than it can access memory in the stack. Some compilers may ignore the hint and use register allocation algorithms to figure out the best candidates to be placed within the available machine registers. Because the compiler is aware of the machine architecture on which the program is run, it is often able to make a more informed decision when selecting the content of machine registers.</p>
<p>Usually, automatic objects used heavily within a function can be declared with the keyword <strong>register</strong>. If possible, the compiler will load the object into a machine register. If it cannot, the object remains in memory.</p>
<p>To declare a register variable, we preface the type with the keyword <strong>register</strong>:</p>
<pre>
register int heavy_use;
</pre>
<p>Array indexes and pointers occurring within a loop are good candidates for register objects.</p>
<pre>
for (register int i = 0; i < sz ; i++)  
...
for (register int *ip = array; p < arraySize ; p++)
</pre>
<p>If a variable is stored in a register, it doesn't have a memory address. So, we can't apply the address operator to a register variable. Therefore, in the following code, it's okay to take the address of the variable <strong>xStack</strong> but not of the register variable <strong>xRegister</strong>:</p>
<pre>
void f(int *);
int main()
{
  int xStack;
  int register xRegister;
  f(&xStack)     // ok
  f(&xRegister)  // not ok
  ...
}
</pre>
<br />
<br />
<div class="subtitle" id="typedef">typedef</div>
<p>We use <strong>typedef</strong> to create an alias:</p>
<pre>
<font color="red">typedef</font> typeName aliasName;
</pre>
<p>So, we can make <strong>byte_pointer</strong> an alias for <strong>char *</strong>:</p>
<pre>
typedef char* byte_pointer;
</pre>
<br />
<br />

<div class="subtitle" id="using">using</div>
<p>C++ provides two mechanisms to qualify names:</p>
<ul>
    <li><strong>using declaration</strong> lets us to make particular identifiers available.
<pre>
using Stock::order;     // a using declaration
</pre>
    </li>
    <li><strong>using directives</strong> makes the entire namespace accessible.
<pre>
using namespace Stock;  // make all the names in Stock available
</pre>
     </li> 
</ul>
<br />
<br />

<div class="subtitle" id="volatile">Volatile</div>
<p>The <strong>volatile</strong> keyword indicates that the value in a memory location can be altered even though nothing in the program code modifies the contents. In other words, <strong>volatile</strong> informs the compiler that the value of the variable can change from the outside, without any update done by the code.</p>
<p>For example, we could have a pointer to a hardware location. The hardware, not the program, may change the value of that address. </p>
<p>The intent of volatile keyword is to improve the <strong>optimization</strong> of compilers. In that optimization, compilers, can cache a value in a register if it's used several times with the same value, under the assumption the variable doesn't change during those uses. If we don't declare a variable as <strong>volatile</strong>, then the compiler may make the optimization. If we do declare a variable as volatile, we're telling the compiler not to make the optimization of the code referring to the object.</p>

<br />
<br />


<img src="images/keyword/WalChoolSan.png" alt="WalChoolSan"/>
<br />
<br />

<div class="subtitle_2nd" id="FullList">List of C++ Tutorials</div>
<div class="bodytext" style="padding: 12px;" align="justify"> 
<ul>
   <li><a href="cpptut.html">C++ Home</a> </li>
   <li><a href="string.html">String</a> </li>
   <li><a href="constructor.html">Constructor</a> </li>
   <li><a href="operatoroverloading.html">Operator Overloading</a></li> 
   <li><a href="virtualfunctions.html">Virtual Functions</a></li>
   <li><a href="dynamic_cast.html">Dynamic Cast Operator</a></li>
   <li><a href="typecast.html">Type Cast Operators</a></li>
   <li><a href="autoptr.html">Class auto_ptr</a></li>
   <li><a href="templates.html">Templates</a></li>
   <li><a href="references.html">References for Built-in Types</a></li>
   <li><a href="valuevsreference.html">Pass by Value vs. Pass by Reference</a></li>
   <li><a href="memoryallocation.html">Memory Allocation</a></li>
   <li><a href="friendclass.html">Friend Functions and Friend Classes</a></li>
   <li><a href="functors.html">Functors (Function Objects)</a></li>
   <li><a href="statics.html">Static Variables and Static Class Members</a></li>
   <li><a href="exceptions.html">Exceptions</a></li>
   <li><a href="pointers.html">Pointers</a></li>
   <li><a href="pointers2.html">Pointers II - void*, Pointer/Array, and Pointer to Pointer</a></li>
   <li><a href="pointers3.html">Pointers III - Pointer to Function, Null Pointer</a></li>
   <li><a href="assembly.html">Taste of Assembly</a></li>
   <li><a href="smallprograms.html">Small Programs</a></li>
   <li><a href="linkedlist.html">Linked List Examples</a></li>
   <li><a href="binarytree.html">Binary Tree Example Code</a></li>
   <li><a href="stl.html">Standard Template Library (STL)</a></li>
   <li><a href="stl2.html">Standard Template Library (STL) II - Maps</a></li>
   <li><a href="stl3_iterators.html">Standard Template Library (STL) III - Iterators</a></li>
   <li><a href="slicing.html">Object Slicing and Virtual Table</a></li>
   <li><a href="this_pointer.html">The this Pointer</a></li>
   <li><a href="stackunwinding.html">Stack Unwinding</a></li>
   <li><a href="upcasting_downcasting.html">Upcasting and Downcasting</a></li>
   <li><a href="object_returning.html">Object Returning</a></li>
   <li><a href="private_inheritance.html">Private Inheritance</a></li>
   <li><a href="cplusplus_keywords.html">C++_Keywords</a></li>
   <li><a href="multithreaded.html">Multi-Threaded Programming - Terminology</a></li>
   <li><a href="multithreaded2A.html">Multi-Threaded Programming II - Native Thread for Win32 (A) </a></li>
   <li><a href="multithreaded2B.html">Multi-Threaded Programming II -  Native Thread for Win32 (B) </a></li>
   <li><a href="multithreaded2C.html">Multi-Threaded Programming II -  Native Thread for Win32 (C) </a></li>
   <li><a href="multithreaded2.html">Multi-Threaded Programming II - C++ Thread for Win32</a></li>
   <li><a href="multithreaded3.html">Multi-Threaded Programming III - C++ Class Thread for Pthreads</a></li>
   <li><a href="multithreadedDebugging.html">Multithread Debugging</a></li>
   <li><a href="embeddedSystemsProgramming.html">Embedded Systems Programming</a></li>
   <li><a href="boost.html">Boost</a></li>
   <li>Programming Questions and Solutions
    <ul>
       <li><a href="quiz_strings_arrays.html">Strings and Arrays</a></li>
       <li><a href="quiz_linkedlist.html">Linked List</a></li>
       <li><a href="quiz_recursion.html">Recursion</a></li>
       <li><a href="quiz_bit_manipulation.html">Bit Manipulation</a> </li>
       <li><a href="google_interview_questions.html">140 Google Interview Questions</a> </li>
    </ul>
   </li>
</ul>


<br />

<div id="rightpanel">
<div align="center">
</div></div>
<br />

<br />
</div>

<br />
<br />
<br />



<div class="smallgraytext" id="footer"><a href="../index.html">Home</a>
| <a href="../about_us.html">About Us</a>
| <a href="../products.html">products</a>
| <a href="../our_services.html">Our Services</a>
| <a href="#">Contact Us</a>
| Bogotobogo &copy; 2011 | <a target="_blank" href="http://www.bogotobogo.com">Bogotobogo </a></div>
</div>
</div>
</body>
</html>
